﻿//#include <iostream>
//
//using namespace std;
//
//#include <time.h>
//
//struct A
//{
//	int a[10000];
//};
//
//void TestFunc1(A a)
//{
//
//}
//
//void TestFunc2(A& a)
//{
//
//}
//
//void TestRefAndValue()
//{
//	A a;
//	
//	//以值作为函数参数
//	size_t begin1 = clock();
//
//	for (size_t i = 0; i < 10000; ++i)
//	{
//		TestFunc1(a);
//	}
//
//	size_t end1 = clock();
//
//	//以引用作为函数参数
//	size_t begin2 = clock();
//
//	for (size_t i = 0; i < 10000; ++i)
//	{
//		TestFunc2(a);
//	}
//
//	size_t end2 = clock();
//
//	//分别计算两个函数运行结束后的时间
//	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
//	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
//}
//
//int main()
//{
//	TestRefAndValue();
//
//	return 0;
//}



//int main()
//{
//	//权限可以平移/缩小 不能放大
//	double d = 12.34;
//
//	//类型转换
//	int i = d;
//
//	const int& r1 = d;
//
//	int x = 0, y = 1;
//	const int& r2 = x + y;
//
//	return 0;
//}



//int main()
//{
//	int a = 0;
//	int& b = a;//语法上不开空间
//
//	int* p = &a;//语法上要开空间
//	
//	return 0;
//}


//#include <iostream>
//
//using namespace std;
//
//int main()
//{
//	int* ptr = NULL;
//	int& r = *ptr;//底层实现的时候这里实际存的是*ptr的地址，所以还是NULL，并没有对NULL解引用，所以这一步不会报错
//	cout << r << endl;//在这里会出错，因为这里使用r是要对NULL解引用的
//
//	return 0;
//}





//void swap(int& a, int& b)
//{
//	//...
//}
//
////频繁调用的小函数
////C -> 宏函数
////#define ADD(a, b) ((a) + (b))
//
//#include <iostream>
//
//using namespace std;
//
////Debug版本下面默认是不展开的->方便调试
//inline int Add(int a, int b)
//{
//	int ret = a + b;
//	return ret;
//}
//
//int main()
//{
//	int c = Add(1, 2);
//	cout << c << endl;
//
//	return 0;
//}



//#include "F.h"
//
//int main()
//{
//	// 链接错误：⽆法解析的外部符号 "void __cdecl f(int)" (?f@@YAXH@Z)
//	f(10);
//	
//	return 0;
//}






//int main()
//{
//	int j = 0;
//
//	//右边初始化自动推导类型
//	auto i = 0;
//
//	return 0;
//}


//#include <map>
//#include <string>
//
//int main()
//{
//	std::map<std::string, std::string> dict;
//	
//	//以下两行代码是等价的，auto可以替代写起来比较长的类型的定义，简化代码
//	//std::map<std::string, std::string>::iterator it = dict.begin();
//	auto it = dict.begin();
//
//	return 0;
//}


//typedef char* pstring;
//
//int main()
//{
//	//const pstring p1;//err 这里的const修饰的是p1，const修饰的是指针本身就必须要初始化指针
//	const pstring* p2;//这里const修饰的是*p2，p2是可以改变的，所以可以不初始化
//
//	return 0;
//}



//#include <iostream>
//
//using namespace std;
//
//int TestAuto()
//{
//	return 10;
//}
//
//int main()
//{
//	int a = 10;
//	auto b = a;
//	auto c = 'a';
//	auto d = TestAuto();
//
//	cout << typeid(b).name() << endl;//int
//	cout << typeid(c).name() << endl;//char
//	cout << typeid(d).name() << endl;//int
//
//	return 0;
//}



//int main()
//{
//	int x = 10;
//	//以下两行代码是等价的，但是auto*指定了必须是指针，auto就没有要求，传什么都可以
//	auto a = &x;
//	auto* a = &x;
//	
//	//引用
//	auto& c = x;
//
//	return 0;
//}


//void TestAuto()
//{
//	auto a = 1, b = 2;
//	//auto c = 3, d = 4.0;//该行代码会编译失败，因为c和d的初始化表达式类型不同
//}


////此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
//void TestAuto(auto a)
//{
//
//}


//void TestAuto()
//{
//	int a[] = { 1, 2, 3 };
//	//auto b[] = { 4, 5, 6 };//err
//}





//#include <iostream>
//
//using namespace std;
//
//int main()
//{
//	int array[] = { 1, 2, 3, 4, 5 };
//
//	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
//	{
//		array[i] *= 2;
//	}
//
//	for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
//	{
//		cout << array[i] << " ";
//	}
//
//	cout << endl;
//
//	return 0;
//}




//#include <iostream>
//
//using namespace std;
//
//int main()
//{
//	int array[] = { 1, 2, 3, 4, 5 };
//
//	//array中的值赋值给e，改变e不会影响数组中的值，如果想要改数组中的值就要加上引用
//	for (auto& e : array)
//	{
//		e *= 2;
//	}
//	
//	//C++11 范围for
//	//自动取数组array中的值，赋值给x
//	//自动++，自动判断结束
//	for (int x : array)//这里用auto还是具体的类型都可以；变量名也可以随便取
//	{
//		cout << x << " ";
//	}
//
//	cout << endl;
//
//	return 0;
//}


//#include <iostream>
//
//using namespace std;
//
////不支持，因为数组传参之后就变成指针了
//void TestFor(int array[])
//{
//	for (auto& e : array)
//	{
//		cout << e << endl;
//	}
//}



//#include<iostream>
//
//using namespace std;
//
//void f(int x)
//{
//	cout << "f(int x)" << endl;
//}
//
//void f(int* ptr)
//{
//	cout << "f(int* ptr)" << endl;
//}
//
//int main()
//{
//	f(0);
//	
//	// 本想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，调用了f(int x)，因此与程序的初衷相悖。
//	f(NULL);
//	
//	f((int*)NULL);
//	
//	f(nullptr);
//	
//	return 0;
//}



//#include <iostream>
//
//using namespace std;
//
////类和对象
////1个类 实例化 N个对象
//
////C++把struct升级成了类
////1、类里面可以定义函数
////2、struct名称就可以代表类型
//
////C++兼容C中struct的用法
//typedef struct ListNodeC
//{
//	struct ListNodeC* next;
//	int val;
//}LTNode;
//
//struct ListNodeCPP
//{
//	ListNodeCPP* next;
//	int val;
//};
//
//struct Stack
//{
//	//成员函数
//	void Init(int n = 4)
//	{
//		array = (int*)malloc(sizeof(int) * n);
//		
//		if (nullptr == array)
//		{
//			perror("malloc申请空间失败");
//			return;
//		}
//
//		capacity = n;
//		top = 0;
//	}
//
//	//成员变量
//	int* array;
//	size_t capacity;
//	size_t top;
//};
//
//int main()
//{
//	struct Stack st1;
//	st1.Init(100);
//
//	Stack st2;
//	st2.Init();
//
//	LTNode node1;
//	ListNodeCPP node2;
//
//	return 0;
//}








//#include <iostream>
//#include <assert.h>
//
//using namespace std;
//
//class Stack
//{
//public:
//	//成员函数
//	void Init(int n = 4)
//	{
//		array = (int*)malloc(sizeof(int) * n);
//		
//		if (nullptr == array)
//		{
//			perror("malloc申请空间失败");
//			return;
//		}
//
//		capacity = n;
//		top = 0;
//	}
//
//	void Push(int x)
//	{
//		//扩容
//		//...
//
//		array[top++] = x;
//	}
//
//	int Top()
//	{
//		assert(top > 0);
//
//		return array[top - 1];
//	}
//
//private:
//	//成员变量
//	int* array;
//	size_t capacity;
//	size_t top;
//};
//
////封装
//
//int main()
//{
//	class Stack st1;
//	Stack st2;
//	st2.Init();
//	st2.Push(1);
//	st2.Push(2);
//	st2.Push(3);
//	st2.Push(4);
//
//	//cout << st2.array[st2.top] << endl;//err
//	cout << st2.Top() << endl;
//
//	return 0;
//}





//class Date
//{
//public:
//	void Init(int year, int month, int day)
//	{
//		//这样写编译能通过，但是没有初始化上，因为局部优先，局部没有才会到类域里去找
//		year = year;
//		month = month;
//		day = day;
//	}
//
//private:
//	int year;
//	int month;
//	int day;
//};

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;//year_  m_year
	int _month;
	int _day;
};

int main()
{
	Date d;
	d.Init(2024, 3, 31);

	return 0;
}